home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 1999 August / SGI Freeware 1999 August.iso / dist / fw_gsl.idb / usr / freeware / include / gsl_sum.h.z / gsl_sum.h
Encoding:
C/C++ Source or Header  |  1999-07-16  |  3.9 KB  |  126 lines

  1. /* Author:  G. Jungman
  2.  * RCS:     $Id: gsl_sum.h,v 1.7 1998/11/19 20:11:58 bjg Exp $
  3.  */
  4. #ifndef GSL_SUM_H
  5. #define GSL_SUM_H
  6.  
  7. /* Basic Levin-u acceleration method.
  8.  *
  9.  *   array       = array of series elements
  10.  *   array_size  = size of array
  11.  *   q_num       = backward diagonal of numerator; length >= array_size
  12.  *   q_den       = backward diagonal of denominator; length >= array_size
  13.  *   dq_num      = table of numerator derivatives; length >= array_size**2
  14.  *   dq_den      = table of denominator derivatives; length >= array_size**2
  15.  *   dsum        = derivative of sum wrt term i; length >= array_size
  16.  *   sum_accel   = result of summation acceleration
  17.  *   sum_plain   = simple sum of series
  18.  *   precision   = precision estimate
  19.  *
  20.  * See [Fessler et al., ACM TOMS 9, 346 (1983) and TOMS-602]
  21.  */
  22.  
  23. int gsl_sum_levin_u_accel (const double * array, 
  24.                size_t array_size,
  25.                double * q_num,
  26.                double * q_den,
  27.                double * dq_num,
  28.                double * dq_den,
  29.                double * dsum,
  30.                double * sum_accel,
  31.                size_t * n_used,
  32.                double * sum_plain,
  33.                double * precision);
  34.  
  35. int gsl_sum_levin_u_trunc_accel (const double * array, size_t array_size,
  36.                  double * q_num, double * q_den,
  37.                  double * sum_accel, 
  38.                  size_t * n_used,
  39.                  double * sum_plain,
  40.                  double * precision);
  41.  
  42. /* Basic Levin-u acceleration method with constraints on the terms
  43.  * used.
  44.  *
  45.  *   array       = array of series elements
  46.  *   array_size  = size of array
  47.  *   q_num       = backward diagonal of numerator; length >= array_size
  48.  *   min_terms   = minimum number of terms to sum
  49.  *   max_terms   = maximum number of terms to sum
  50.  *   q_den       = backward diagonal of numerator; length >= array_size
  51.  *   dq_num      = table of numerator derivatives; length >= array_size**2
  52.  *   dq_den      = table of denominator derivatives; length >= array_size**2
  53.  *   dsum        = derivative of sum wrt term i; length >= array_size
  54.  *   sum_accel   = result of summation acceleration
  55.  *   sum_plain   = simple sum of series
  56.  *   precision   = precision estimate
  57.  *
  58.  * See [Fessler et al., ACM TOMS 9, 346 (1983) and TOMS-602] */
  59.  
  60.  
  61. int gsl_sum_levin_u_accel_minmax (const double * array, 
  62.                   size_t array_size,
  63.                   size_t min_terms, 
  64.                   size_t max_terms,
  65.                   double * q_num,
  66.                   double * q_den,
  67.                   double * dq_num,
  68.                   double * dq_den,
  69.                   double * dsum,
  70.                   double * sum_accel,
  71.                   size_t * n_used,
  72.                   double * sum_plain,
  73.                   double * precision);
  74.  
  75. int gsl_sum_levin_u_trunc_accel_minmax (const double * array, 
  76.                     size_t array_size,
  77.                     size_t min_terms, 
  78.                     size_t max_terms,
  79.                     double * q_num,
  80.                     double * q_den,
  81.                     double * sum_accel,
  82.                     size_t * n_used,
  83.                     double * sum_plain,
  84.                     double * precision);
  85.  
  86. /* Basic Levin-u step w/o reference to the array of terms.
  87.  * We only need to specify the value of the current term
  88.  * to execute the step. See TOMS-745.
  89.  *
  90.  * sum = t0 + ... + t_{n-1} + term;  term = t_{n}
  91.  *
  92.  *   term   = value of the series term to be added
  93.  *   n      = position of term in series (starting from 0)
  94.  *   q_num  = backward diagonal of numerator, assumed to have size >= n + 1
  95.  *   q_den  = backward diagonal of numerator, assumed to have size >= n + 1
  96.  *   dq_num = table of numerator derivatives; length >= array_size**2
  97.  *   dq_den = table of denominator derivatives; length >= array_size**2
  98.  *   dsum   = derivative of sum wrt term i; length >= array_size
  99.  *   sum_accel = result of summation acceleration
  100.  *   sum_plain = simple sum of series
  101.  */
  102.  
  103. int
  104. gsl_sum_levin_u_step (double term,
  105.               size_t n,
  106.               size_t nmax,
  107.               double *q_num,
  108.               double *q_den,
  109.               double *dq_num,
  110.               double *dq_den,
  111.               double *dsum,
  112.               double *sum_accel,
  113.               double *sum_plain);
  114.  
  115. int gsl_sum_levin_u_trunc_step(double term,
  116.                    size_t n,
  117.                    double * q_num,
  118.                    double * q_den,
  119.                    double * sum_accel,
  120.                    double * sum_plain);
  121.  
  122. #endif  /* GSL_SUM_H */
  123.  
  124.  
  125.  
  126.